<?php
/* SVN FILE: $Id: app_controller.php 105 2007-04-01 19:24:49Z Andy $ */

/**
 * Short description for file.php.
 *
 * Long description for file
 *
 * PHP versions 4 and 5
 *
 * Copyright (c), Andy Dawson
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 *
 * @filesource
 * @copyright    Copyright (c) 2007, Andy Dawson
 * @package      noswad
 * @subpackage   noswad.app
 * @since        Noswad site version 3
 * @todo         TODO Edit this block
 * @version      $Revision: 105 $
 * @created      26/01/2007
 * @modifiedby   $LastChangedBy$
 * @lastmodified $Date: 2007-04-01 21:24:49 +0200 (dom, 01 abr 2007) $
 * @license      http://www.opensource.org/licenses/mit-license.php The MIT License
 */

class NumberTree extends Model {
	var $name= 'NumberTree';
	var $useDbConfig= 'test_suite';
	var $cacheQueries= false;
	var $actsAs = array('Tree');

/**
 * Iniialize table
 *
 * Defaults to creating a tree of 7 nodes, could be used to generate any size of test tree. Default structure:
 * 1. Root
 * 	1.1
 * 		1.1.1
 * 		1.1.2
 * 	1.2
 * 		1.2.1
 * 		1.2.2
 *
 * @param type $name description
 * @return type description
 */
	function __initialize($levelLimit= 3, $childLimit= 3, $currentLevel= null, $parent_id= null, $prefix= '1', $hierachial= true) {
		if (!$parent_id) {
			$this->deleteAll('1=1');
			$this->save(array (
				'NumberTree' => array (
					'name' => '1. Root'
				)
			));
			$this->__initialize($levelLimit, $childLimit, 1, $this->id, '1', $hierachial);
			$this->create(array ());
		}
		if (!$currentLevel) {
			return;
		}
		if ($currentLevel > $levelLimit) {
			return;
		}
		for ($i= 1; $i <= $childLimit; $i++) {
			$name= $prefix . '.' . $i;
			$data= array (
				'NumberTree' => array (
					'name' => $name
				)
			);
			$this->create($data);
			if ($hierachial) {
				$data['NumberTree']['parent_id']= $parent_id;
			}
			$this->save($data);
			$this->__initialize($levelLimit, $childLimit, $currentLevel +1, $this->id, $name, $hierachial);
		}
	}
}

class NumberTreeCase extends CakeTestCase {
	var $fixtures= array (
		'core.number_tree'
	);

	function testInitialize() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$result= $this->NumberTree->findCount();
		$this->assertEqual($result,7);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}
	function testDetectInvalidLeft() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$result= $this->NumberTree->findByName('1.1');

		$save['NumberTree']['id']= $result['NumberTree']['id'];
		$save['NumberTree']['lft']= false;

		$this->NumberTree->save($save);
		$result= $this->NumberTree->verify();
		$this->assertNotIdentical($result, true);

		$this->NumberTree->recover();

		$result= $this->NumberTree->verify();
		$this->assertIdentical($result, true);
	}

	function testDetectInvalidRight() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$result= $this->NumberTree->findByName('1.1');

		$save['NumberTree']['id']= $result['NumberTree']['id'];
		$save['NumberTree']['rght']= false;

		$this->NumberTree->save($save);
		$result= $this->NumberTree->verify();
		$this->assertNotIdentical($result, true);

		$this->NumberTree->recover();

		$result= $this->NumberTree->verify();
		$this->assertIdentical($result, true);
	}

	function testDetectInvalidParent() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$result= $this->NumberTree->findByName('1.1');

		// Bypass behavior and any other logic
		$this->NumberTree->updateAll(array (
			'parent_id' => null
		), array (
			'id' => $result['NumberTree']['id']
		));

		$result= $this->NumberTree->verify();
		$this->assertNotIdentical($result, true);

		$this->NumberTree->recover();

		$result= $this->NumberTree->verify();
		$this->assertIdentical($result, true);
	}

	function testDetectNoneExistantParent() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$result= $this->NumberTree->findByName('1.1');

		// Bypass behavior and any other logic
		$this->NumberTree->updateAll(array (
			'parent_id' => 999999
		), array (
			'id' => $result['NumberTree']['id']
		));

		$result= $this->NumberTree->verify();
		$this->assertNotIdentical($result, true);

		$this->NumberTree->recover('MPTT');

		$result= $this->NumberTree->verify();
		$this->assertIdentical($result, true);
	}

	function testDetectInvalidParents() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$this->NumberTree->updateAll(array (
			'parent_id' => null
		));

		$result= $this->NumberTree->verify();
		$this->assertNotIdentical($result, true);

		$this->NumberTree->recover();

		$result= $this->NumberTree->verify();
		$this->assertIdentical($result, true);
	}

	function testDetectInvalidLftsRghts() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$this->NumberTree->updateAll(array (
			'lft' => null,
			'rght' => null
		));

		$result= $this->NumberTree->verify();
		$this->assertNotIdentical($result, true);

		$this->NumberTree->recover();

		$result= $this->NumberTree->verify();
		$this->assertIdentical($result, true);
	}

	function testAddOrphan() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$this->NumberTree->save(array (
			'NumberTree' => array (
				'name' => __METHOD__,
				'parent_id' => null
			)
		));
		// Find the last item in the tree
		$result= $this->NumberTree->find(null, array (
			'name',
			'parent_id'
		), 'NumberTree.lft desc');
		$expected= array (
			'NumberTree' => array (
				'name' => __METHOD__,
				'parent_id' => null
			)
		);
		$this->assertEqual($result, $expected);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testAddMiddle() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.1'
		), array (
			'id'
		));
		$initialCount= $this->NumberTree->findCount();

		$this->NumberTree->create();
		$saveSuccess= $this->NumberTree->save(array (
			'NumberTree' => array (
				'name' => __METHOD__,
				'parent_id' => $data['NumberTree']['id']
			)
		));
		$this->assertIdentical($saveSuccess, true);

		$laterCount= $this->NumberTree->findCount();

		$laterCount= $this->NumberTree->findCount();
		$this->assertEqual($initialCount +1, $laterCount);

		$children= $this->NumberTree->children($data['NumberTree']['id'], true, array (
			'name'
		));
		$expects= array (
			array (
				'NumberTree' => array (
					'name' => '1.1.1'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.1.2'
				)
			),
			array (
				'NumberTree' => array (
					'name' => __METHOD__
				)
			)
		);
		$this->assertIdentical($children, $expects);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testAddInvalid() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);
		$this->NumberTree->id= null;

		$initialCount= $this->NumberTree->findCount();

		$this->expectError('Trying to save a node under a none-existant node in TreeBehavior::beforeSave');
		$saveSuccess= $this->NumberTree->save(array (
			'NumberTree' => array (
				'name' => __METHOD__,
				'parent_id' => 99999
			)
		));
		$this->assertIdentical($saveSuccess, false);
		$laterCount= $this->NumberTree->findCount();
		$this->assertIdentical($initialCount, $laterCount);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testMovePromote() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);
		$this->NumberTree->id= null;

		$parent= $this->NumberTree->find(array (
			'NumberTree.name' => '1. Root'
		));
		$parent_id= $parent['NumberTree']['id'];

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.1.1'
		), array (
			'id'
		));
		$this->NumberTree->id= $data['NumberTree']['id'];
		$this->NumberTree->saveField('parent_id', $parent_id);
		$direct= $this->NumberTree->children($parent_id, true);
		$expects= array (
			array (
				'NumberTree' => array (
					'id' => 2,
					'name' => '1.1',
					'parent_id' => 1,
					'lft' => 2,
					'rght' => 5
				)
			),
			array (
				'NumberTree' => array (
					'id' => 5,
					'name' => '1.2',
					'parent_id' => 1,
					'lft' => 6,
					'rght' => 11
				)
			),
			array (
				'NumberTree' => array (
					'id' => 3,
					'name' => '1.1.1',
					'parent_id' => 1,
					'lft' => 12,
					'rght' => 13
				)
			)
		);
		$this->assertEqual($direct, $expects);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testMoveBefore() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);
		$this->NumberTree->id= null;

		$parent= $this->NumberTree->find(array (
			'NumberTree.name' => '1.1'
		));
		$parent_id= $parent['NumberTree']['id'];

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.2'
		), array (
			'id'
		));
		$this->NumberTree->id= $data['NumberTree']['id'];
		$this->NumberTree->saveField('parent_id', $parent_id);

		$result= $this->NumberTree->children($parent_id, true, array ('name'));
		$expects= array (
			array (
				'NumberTree' => array (
					'name' => '1.1.1'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.1.2'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.2'
				)
			)
		);
		$this->assertEqual($result, $expects);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testMoveAfter() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);
		$this->NumberTree->id= null;

		$parent= $this->NumberTree->find(array (
			'NumberTree.name' => '1.2'
		));
		$parent_id= $parent['NumberTree']['id'];

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.1'
		), array (
			'id'
		));
		$this->NumberTree->id= $data['NumberTree']['id'];
		$this->NumberTree->saveField('parent_id', $parent_id);

		$result= $this->NumberTree->children($parent_id, true, array ('name'));
		$expects= array (
			array (
				'NumberTree' => array (
					'name' => '1.2.1'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.2.2'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.1'
				)
			)
		);
		$this->assertEqual($result, $expects);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testMoveDemoteInvalid() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);
		$this->NumberTree->id= null;

		$parent= $this->NumberTree->find(array (
			'NumberTree.name' => '1. Root'
		));
		$parent_id= $parent['NumberTree']['id'];

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.1.1'
		), array (
			'id'
		));

		$expects= $this->NumberTree->findAll();
		$before= $this->NumberTree->read(null, $data['NumberTree']['id']);

		$this->NumberTree->id= $parent_id;
		$this->expectError('Trying to save a node under itself in TreeBehavior::beforeSave');
		$this->NumberTree->saveField('parent_id', $data['NumberTree']['id']);

		$results= $this->NumberTree->findAll();
		$after= $this->NumberTree->read(null, $data['NumberTree']['id']);

		$this->assertEqual($results, $expects);
		$this->assertEqual($before, $after);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testMoveToEnd() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);
		$this->NumberTree->id= null;

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.1'
		), array (
			'id'
		));
		$this->NumberTree->id= $data['NumberTree']['id'];
		$this->NumberTree->saveField('parent_id', null);
		// Find the last parent node in the tree
		$result= $this->NumberTree->find(null, array (
			'name',
			'parent_id'
		), 'NumberTree.rght desc');
		$expected= array (
			'NumberTree' => array (
				'name' => '1.1',
				'parent_id' => null
			)
		);
		$this->assertEqual($result, $expected);
	}

	function testMoveInvalid() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);
		$this->NumberTree->id= null;

		$initialCount= $this->NumberTree->findCount();
		$data= $this->NumberTree->findByName('1.1');

		$this->expectError('Trying to save a node under a none-existant node in TreeBehavior::beforeSave');
		$this->NumberTree->id= $data['NumberTree']['id'];
		$saveSuccess= $this->NumberTree->saveField('parent_id', 999999);

		$this->assertIdentical($saveSuccess, false);
		$laterCount= $this->NumberTree->findCount();
		$this->assertIdentical($initialCount, $laterCount);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testMoveSelfInvalid() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);
		$this->NumberTree->id= null;

		$initialCount= $this->NumberTree->findCount();
		$data= $this->NumberTree->findByName('1.1');

		$this->expectError('Trying to set a node to be the parent of itself in TreeBehavior::beforeSave');
		$this->NumberTree->id= $data['NumberTree']['id'];
		$saveSuccess= $this->NumberTree->saveField('parent_id', $this->NumberTree->id);

		$this->assertIdentical($saveSuccess, false);
		$laterCount= $this->NumberTree->findCount();
		$this->assertIdentical($initialCount, $laterCount);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testMoveUpSuccess() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.2'
		), array (
			'id'
		));
		$this->NumberTree->move_up($data['NumberTree']['id']);

		$parent= $this->NumberTree->findByName('1. Root', array (
			'id'
		));
		$this->NumberTree->id= $parent['NumberTree']['id'];
		$result= $this->NumberTree->children(null, true, array ('name'));
		$expected= array (
			array (
				'NumberTree' => array (
					'name' => '1.2',


				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.1',


				)
			)
		);
		$this->assertIdentical($result, $expected);
	}

	function testMoveUpFail() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.1'
		));

		$this->NumberTree->move_up($data['NumberTree']['id']);

		$parent= $this->NumberTree->findByName('1. Root', array (
			'id'
		));
		$this->NumberTree->id= $parent['NumberTree']['id'];
		$result= $this->NumberTree->children(null, true, array ('name'));
		$expected= array (
			array (
				'NumberTree' => array (
					'name' => '1.1',


				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.2',


				)
			)
		);
		$this->assertIdentical($result, $expected);
	}

	function testMoveDownSuccess() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.1'
		), array (
			'id'
		));
		$this->NumberTree->move_down($data['NumberTree']['id']);

		$parent= $this->NumberTree->findByName('1. Root', array (
			'id'
		));
		$this->NumberTree->id= $parent['NumberTree']['id'];
		$result= $this->NumberTree->children(null, true, array ('name'));
		$expected= array (
			array (
				'NumberTree' => array (
					'name' => '1.2',


				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.1',


				)
			)
		);
		$this->assertIdentical($result, $expected);
	}

	function testMoveDownFail() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.2'
		));
		$this->NumberTree->move_down($data['NumberTree']['id']);

		$parent= $this->NumberTree->findByName('1. Root', array (
			'id'
		));
		$this->NumberTree->id= $parent['NumberTree']['id'];
		$result= $this->NumberTree->children(null, true, array ('name'));
		$expected= array (
			array (
				'NumberTree' => array (
					'name' => '1.1',


				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.2',


				)
			)
		);
		$this->assertIdentical($result, $expected);
	}

	function testDelete() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$initialCount= $this->NumberTree->findCount();
		$result= $this->NumberTree->findByName('1.1.1');

		$this->NumberTree->delete($result['NumberTree']['id']);

		$laterCount= $this->NumberTree->findCount();
		$this->assertEqual($initialCount -1, $laterCount);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);

		$initialCount= $this->NumberTree->findCount();
		$result= $this->NumberTree->findByName('1.1');

		// Node now has a single child
		$this->NumberTree->delete($result['NumberTree']['id']);

		$laterCount= $this->NumberTree->findCount();
		$this->assertEqual($initialCount -2, $laterCount);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testRemove() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);
		$initialCount= $this->NumberTree->findCount();
		$result= $this->NumberTree->findByName('1.1');

		$this->NumberTree->remove_from_tree($result['NumberTree']['id']);

		$laterCount= $this->NumberTree->findCount();
		$this->assertEqual($initialCount, $laterCount);

		$children= $this->NumberTree->children($result['NumberTree']['parent_id'], true, array ('name'));
		$expects= array (
			array (
				'NumberTree' => array (
					'name' => '1.1.1'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.1.2'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.2'
				)
			)
		);
		$this->assertEqual($children, $expects);

		$topNodes = $this->NumberTree->children(false,true,array('name'));
		$expects= array (
			array (
				'NumberTree' => array (
					'name' => '1. Root'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.1'
				)
			)
		);
		$this->assertEqual($topNodes, $expects);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testRemoveLastTopParent () {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$initialCount= $this->NumberTree->findCount();
		$initialTopNodes = $this->NumberTree->child_count(false);

		$result= $this->NumberTree->findByName('1. Root');
		$this->NumberTree->remove_from_tree($result['NumberTree']['id']);

		$laterCount= $this->NumberTree->findCount();
		$laterTopNodes = $this->NumberTree->child_count(false);

		$this->assertEqual($initialCount, $laterCount);
		$this->assertEqual($initialTopNodes, $laterTopNodes);

		$topNodes = $this->NumberTree->children(false,true,array('name'));
		$expects= array (
			array (
				'NumberTree' => array (
					'name' => '1.1'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.2'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1. Root'
				)
			)
		);

		$this->assertEqual($topNodes, $expects);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testRemoveAndDelete() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$initialCount= $this->NumberTree->findCount();
		$result= $this->NumberTree->findByName('1.1');

		$this->NumberTree->remove_from_tree($result['NumberTree']['id'],true);

		$laterCount= $this->NumberTree->findCount();
		$this->assertEqual($initialCount-1, $laterCount);

		$children= $this->NumberTree->children($result['NumberTree']['parent_id'], true, array (
			'name'
		), 'lft asc');
		$expects= array (
			array (
				'NumberTree' => array (
					'name' => '1.1.1'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.1.2'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.2'
				)
			)
		);
		$this->assertEqual($children, $expects);

		$topNodes = $this->NumberTree->children(false,true,array('name'));
		$expects= array (
			array (
				'NumberTree' => array (
					'name' => '1. Root'
				)
			)
		);
		$this->assertEqual($topNodes, $expects);

		$validTree= $this->NumberTree->verify();
		$this->assertIdentical($validTree, true);
	}

	function testChildren() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1. Root'
		));
		$this->NumberTree->id= $data['NumberTree']['id'];

		$direct= $this->NumberTree->children(null, true);
		$expects= array (
			array (
				'NumberTree' => array (
					'id' => 2,
					'name' => '1.1',
					'parent_id' => 1,
					'lft' => 2,
					'rght' => 7
				)
			),
			array (
				'NumberTree' => array (
					'id' => 5,
					'name' => '1.2',
					'parent_id' => 1,
					'lft' => 8,
					'rght' => 13
				)
			)
		);
		$this->assertEqual($direct, $expects);

		$expects= array (
			array (
				'NumberTree' => array (
					'id' => 2,
					'name' => '1.1',
					'parent_id' => 1,
					'lft' => 2,
					'rght' => 7
				)
			),
			array (
				'NumberTree' => array (
					'id' => 3,
					'name' => '1.1.1',
					'parent_id' => 2,
					'lft' => 3,
					'rght' => 4
				)
			),
			array (
				'NumberTree' => array (
					'id' => 4,
					'name' => '1.1.2',
					'parent_id' => 2,
					'lft' => 5,
					'rght' => 6
				)
			),
			array (
				'NumberTree' => array (
					'id' => 5,
					'name' => '1.2',
					'parent_id' => 1,
					'lft' => 8,
					'rght' => 13
				)
			),
			array (
				'NumberTree' => array (
					'id' => 6,
					'name' => '1.2.1',
					'parent_id' => 5,
					'lft' => 9,
					'rght' => 10
				)
			),
			array (
				'NumberTree' => array (
					'id' => 7,
					'name' => '1.2.2',
					'parent_id' => 5,
					'lft' => 11,
					'rght' => 12
				)
			)
		);
		$total= $this->NumberTree->children();
		$this->assertEqual($total, $expects);
	}

	function testChildCount() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1. Root'
		));
		$this->NumberTree->id= $data['NumberTree']['id'];

		$direct= $this->NumberTree->child_count(null, true);
		$this->assertEqual($direct, 2);

		$expects= $this->NumberTree->findCount() - 1;
		$total= $this->NumberTree->child_count();
		$this->assertEqual($total, 6);
	}

	function testGetParentNode() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.2.2'
		));
		$this->NumberTree->id= $data['NumberTree']['id'];

		$result= $this->NumberTree->get_parent_node(null, array (
			'name'
		));
		$expects= array (
			'NumberTree' => array (
				'name' => '1.2'
			)
		);
		$this->assertIdentical($result, $expects);
	}

	function testGetPath() {
		$this->NumberTree= & new NumberTree();
		$this->NumberTree->__initialize(2, 2);

		$data= $this->NumberTree->find(array (
			'NumberTree.name' => '1.2.2'
		));
		$this->NumberTree->id= $data['NumberTree']['id'];

		$result= $this->NumberTree->get_path(null, array (
			'name'
		));
		$expects= array (
			array (
				'NumberTree' => array (
					'name' => '1. Root'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.2'
				)
			),
			array (
				'NumberTree' => array (
					'name' => '1.2.2'
				)
			)
		);
		$this->assertIdentical($result, $expects);
	}
}
?>